home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / Collections.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  17.1 KB  |  721 lines
  1. package java.util;
  2.  
  3. public class Collections {
  4.    private static final int BINARYSEARCH_THRESHOLD = 5000;
  5.    private static final int REVERSE_THRESHOLD = 18;
  6.    private static final int SHUFFLE_THRESHOLD = 5;
  7.    private static final int FILL_THRESHOLD = 25;
  8.    private static final int ROTATE_THRESHOLD = 100;
  9.    private static final int COPY_THRESHOLD = 10;
  10.    private static final int REPLACEALL_THRESHOLD = 11;
  11.    private static final int INDEXOFSUBLIST_THRESHOLD = 35;
  12.    // $FF: renamed from: r java.util.Random
  13.    private static Random field_0;
  14.    public static final Set EMPTY_SET = new EmptySet((1)null);
  15.    public static final List EMPTY_LIST = new EmptyList((1)null);
  16.    public static final Map EMPTY_MAP = new EmptyMap((1)null);
  17.    private static final Comparator REVERSE_ORDER = new ReverseComparator((1)null);
  18.  
  19.    private Collections() {
  20.    }
  21.  
  22.    public static <T extends Comparable<? super T>> void sort(List<T> var0) {
  23.       Object[] var1 = var0.toArray();
  24.       Arrays.sort(var1);
  25.       ListIterator var2 = var0.listIterator();
  26.  
  27.       for(int var3 = 0; var3 < var1.length; ++var3) {
  28.          var2.next();
  29.          var2.set((Comparable)var1[var3]);
  30.       }
  31.  
  32.    }
  33.  
  34.    public static <T> void sort(List<T> var0, Comparator<? super T> var1) {
  35.       Object[] var2 = var0.toArray();
  36.       Arrays.sort(var2, var1);
  37.       ListIterator var3 = var0.listIterator();
  38.  
  39.       for(int var4 = 0; var4 < var2.length; ++var4) {
  40.          var3.next();
  41.          var3.set(var2[var4]);
  42.       }
  43.  
  44.    }
  45.  
  46.    public static <T> int binarySearch(List<? extends Comparable<? super T>> var0, T var1) {
  47.       return !(var0 instanceof RandomAccess) && var0.size() >= 5000 ? iteratorBinarySearch(var0, var1) : indexedBinarySearch(var0, var1);
  48.    }
  49.  
  50.    private static <T> int indexedBinarySearch(List<? extends Comparable<? super T>> var0, T var1) {
  51.       int var2 = 0;
  52.       int var3 = var0.size() - 1;
  53.  
  54.       while(var2 <= var3) {
  55.          int var4 = var2 + var3 >>> 1;
  56.          Comparable var5 = (Comparable)var0.get(var4);
  57.          int var6 = var5.compareTo(var1);
  58.          if (var6 < 0) {
  59.             var2 = var4 + 1;
  60.          } else {
  61.             if (var6 <= 0) {
  62.                return var4;
  63.             }
  64.  
  65.             var3 = var4 - 1;
  66.          }
  67.       }
  68.  
  69.       return -(var2 + 1);
  70.    }
  71.  
  72.    private static <T> int iteratorBinarySearch(List<? extends Comparable<? super T>> var0, T var1) {
  73.       int var2 = 0;
  74.       int var3 = var0.size() - 1;
  75.       ListIterator var4 = var0.listIterator();
  76.  
  77.       while(var2 <= var3) {
  78.          int var5 = var2 + var3 >>> 1;
  79.          Comparable var6 = (Comparable)get(var4, var5);
  80.          int var7 = var6.compareTo(var1);
  81.          if (var7 < 0) {
  82.             var2 = var5 + 1;
  83.          } else {
  84.             if (var7 <= 0) {
  85.                return var5;
  86.             }
  87.  
  88.             var3 = var5 - 1;
  89.          }
  90.       }
  91.  
  92.       return -(var2 + 1);
  93.    }
  94.  
  95.    private static <T> T get(ListIterator<? extends T> var0, int var1) {
  96.       Object var2 = null;
  97.       int var3 = var0.nextIndex();
  98.       if (var3 <= var1) {
  99.          do {
  100.             var2 = var0.next();
  101.          } while(var3++ < var1);
  102.       } else {
  103.          do {
  104.             var2 = var0.previous();
  105.             --var3;
  106.          } while(var3 > var1);
  107.       }
  108.  
  109.       return (T)var2;
  110.    }
  111.  
  112.    public static <T> int binarySearch(List<? extends T> var0, T var1, Comparator<? super T> var2) {
  113.       if (var2 == null) {
  114.          return binarySearch(var0, var1);
  115.       } else {
  116.          return !(var0 instanceof RandomAccess) && var0.size() >= 5000 ? iteratorBinarySearch(var0, var1, var2) : indexedBinarySearch(var0, var1, var2);
  117.       }
  118.    }
  119.  
  120.    private static <T> int indexedBinarySearch(List<? extends T> var0, T var1, Comparator<? super T> var2) {
  121.       int var3 = 0;
  122.       int var4 = var0.size() - 1;
  123.  
  124.       while(var3 <= var4) {
  125.          int var5 = var3 + var4 >>> 1;
  126.          Object var6 = var0.get(var5);
  127.          int var7 = var2.compare(var6, var1);
  128.          if (var7 < 0) {
  129.             var3 = var5 + 1;
  130.          } else {
  131.             if (var7 <= 0) {
  132.                return var5;
  133.             }
  134.  
  135.             var4 = var5 - 1;
  136.          }
  137.       }
  138.  
  139.       return -(var3 + 1);
  140.    }
  141.  
  142.    private static <T> int iteratorBinarySearch(List<? extends T> var0, T var1, Comparator<? super T> var2) {
  143.       int var3 = 0;
  144.       int var4 = var0.size() - 1;
  145.       ListIterator var5 = var0.listIterator();
  146.  
  147.       while(var3 <= var4) {
  148.          int var6 = var3 + var4 >>> 1;
  149.          Object var7 = get(var5, var6);
  150.          int var8 = var2.compare(var7, var1);
  151.          if (var8 < 0) {
  152.             var3 = var6 + 1;
  153.          } else {
  154.             if (var8 <= 0) {
  155.                return var6;
  156.             }
  157.  
  158.             var4 = var6 - 1;
  159.          }
  160.       }
  161.  
  162.       return -(var3 + 1);
  163.    }
  164.  
  165.    public static void reverse(List<?> var0) {
  166.       int var1 = var0.size();
  167.       if (var1 >= 18 && !(var0 instanceof RandomAccess)) {
  168.          ListIterator var7 = var0.listIterator();
  169.          ListIterator var8 = var0.listIterator(var1);
  170.          int var9 = 0;
  171.  
  172.          for(int var5 = var0.size() >> 1; var9 < var5; ++var9) {
  173.             Object var6 = var7.next();
  174.             var7.set(var8.previous());
  175.             var8.set(var6);
  176.          }
  177.       } else {
  178.          int var2 = 0;
  179.          int var3 = var1 >> 1;
  180.  
  181.          for(int var4 = var1 - 1; var2 < var3; --var4) {
  182.             swap(var0, var2, var4);
  183.             ++var2;
  184.          }
  185.       }
  186.  
  187.    }
  188.  
  189.    public static void shuffle(List<?> var0) {
  190.       if (field_0 == null) {
  191.          field_0 = new Random();
  192.       }
  193.  
  194.       shuffle(var0, field_0);
  195.    }
  196.  
  197.    public static void shuffle(List<?> var0, Random var1) {
  198.       int var2 = var0.size();
  199.       if (var2 >= 5 && !(var0 instanceof RandomAccess)) {
  200.          Object[] var6 = var0.toArray();
  201.  
  202.          for(int var4 = var2; var4 > 1; --var4) {
  203.             swap(var6, var4 - 1, var1.nextInt(var4));
  204.          }
  205.  
  206.          ListIterator var7 = var0.listIterator();
  207.  
  208.          for(int var5 = 0; var5 < var6.length; ++var5) {
  209.             var7.next();
  210.             var7.set(var6[var5]);
  211.          }
  212.       } else {
  213.          for(int var3 = var2; var3 > 1; --var3) {
  214.             swap(var0, var3 - 1, var1.nextInt(var3));
  215.          }
  216.       }
  217.  
  218.    }
  219.  
  220.    public static void swap(List<?> var0, int var1, int var2) {
  221.       var0.set(var1, var0.set(var2, var0.get(var1)));
  222.    }
  223.  
  224.    private static void swap(Object[] var0, int var1, int var2) {
  225.       Object var3 = var0[var1];
  226.       var0[var1] = var0[var2];
  227.       var0[var2] = var3;
  228.    }
  229.  
  230.    public static <T> void fill(List<? super T> var0, T var1) {
  231.       int var2 = var0.size();
  232.       if (var2 >= 25 && !(var0 instanceof RandomAccess)) {
  233.          ListIterator var5 = var0.listIterator();
  234.  
  235.          for(int var4 = 0; var4 < var2; ++var4) {
  236.             var5.next();
  237.             var5.set(var1);
  238.          }
  239.       } else {
  240.          for(int var3 = 0; var3 < var2; ++var3) {
  241.             var0.set(var3, var1);
  242.          }
  243.       }
  244.  
  245.    }
  246.  
  247.    public static <T> void copy(List<? super T> var0, List<? extends T> var1) {
  248.       int var2 = var1.size();
  249.       if (var2 > var0.size()) {
  250.          throw new IndexOutOfBoundsException("Source does not fit in dest");
  251.       } else {
  252.          if (var2 < 10 || var1 instanceof RandomAccess && var0 instanceof RandomAccess) {
  253.             for(int var6 = 0; var6 < var2; ++var6) {
  254.                var0.set(var6, var1.get(var6));
  255.             }
  256.          } else {
  257.             ListIterator var3 = var0.listIterator();
  258.             ListIterator var4 = var1.listIterator();
  259.  
  260.             for(int var5 = 0; var5 < var2; ++var5) {
  261.                var3.next();
  262.                var3.set(var4.next());
  263.             }
  264.          }
  265.  
  266.       }
  267.    }
  268.  
  269.    public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> var0) {
  270.       Iterator var1 = var0.iterator();
  271.       Object var2 = var1.next();
  272.  
  273.       while(var1.hasNext()) {
  274.          Object var3 = var1.next();
  275.          if (((Comparable)var3).compareTo(var2) < 0) {
  276.             var2 = var3;
  277.          }
  278.       }
  279.  
  280.       return (T)var2;
  281.    }
  282.  
  283.    public static <T> T min(Collection<? extends T> var0, Comparator<? super T> var1) {
  284.       if (var1 == null) {
  285.          return (T)min(var0);
  286.       } else {
  287.          Iterator var2 = var0.iterator();
  288.          Object var3 = var2.next();
  289.  
  290.          while(var2.hasNext()) {
  291.             Object var4 = var2.next();
  292.             if (var1.compare(var4, var3) < 0) {
  293.                var3 = var4;
  294.             }
  295.          }
  296.  
  297.          return (T)var3;
  298.       }
  299.    }
  300.  
  301.    public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> var0) {
  302.       Iterator var1 = var0.iterator();
  303.       Object var2 = var1.next();
  304.  
  305.       while(var1.hasNext()) {
  306.          Object var3 = var1.next();
  307.          if (((Comparable)var3).compareTo(var2) > 0) {
  308.             var2 = var3;
  309.          }
  310.       }
  311.  
  312.       return (T)var2;
  313.    }
  314.  
  315.    public static <T> T max(Collection<? extends T> var0, Comparator<? super T> var1) {
  316.       if (var1 == null) {
  317.          return (T)max(var0);
  318.       } else {
  319.          Iterator var2 = var0.iterator();
  320.          Object var3 = var2.next();
  321.  
  322.          while(var2.hasNext()) {
  323.             Object var4 = var2.next();
  324.             if (var1.compare(var4, var3) > 0) {
  325.                var3 = var4;
  326.             }
  327.          }
  328.  
  329.          return (T)var3;
  330.       }
  331.    }
  332.  
  333.    public static void rotate(List<?> var0, int var1) {
  334.       if (!(var0 instanceof RandomAccess) && var0.size() >= 100) {
  335.          rotate2(var0, var1);
  336.       } else {
  337.          rotate1(var0, var1);
  338.       }
  339.  
  340.    }
  341.  
  342.    private static <T> void rotate1(List<T> var0, int var1) {
  343.       int var2 = var0.size();
  344.       if (var2 != 0) {
  345.          var1 %= var2;
  346.          if (var1 < 0) {
  347.             var1 += var2;
  348.          }
  349.  
  350.          if (var1 != 0) {
  351.             int var3 = 0;
  352.  
  353.             for(int var4 = 0; var4 != var2; ++var3) {
  354.                Object var5 = var0.get(var3);
  355.                int var6 = var3;
  356.  
  357.                while(true) {
  358.                   var6 += var1;
  359.                   if (var6 >= var2) {
  360.                      var6 -= var2;
  361.                   }
  362.  
  363.                   var5 = var0.set(var6, var5);
  364.                   ++var4;
  365.                   if (var6 == var3) {
  366.                      break;
  367.                   }
  368.                }
  369.             }
  370.  
  371.          }
  372.       }
  373.    }
  374.  
  375.    private static void rotate2(List<?> var0, int var1) {
  376.       int var2 = var0.size();
  377.       if (var2 != 0) {
  378.          int var3 = -var1 % var2;
  379.          if (var3 < 0) {
  380.             var3 += var2;
  381.          }
  382.  
  383.          if (var3 != 0) {
  384.             reverse(var0.subList(0, var3));
  385.             reverse(var0.subList(var3, var2));
  386.             reverse(var0);
  387.          }
  388.       }
  389.    }
  390.  
  391.    public static <T> boolean replaceAll(List<T> var0, T var1, T var2) {
  392.       boolean var3 = false;
  393.       int var4 = var0.size();
  394.       if (var4 >= 11 && !(var0 instanceof RandomAccess)) {
  395.          ListIterator var8 = var0.listIterator();
  396.          if (var1 == null) {
  397.             for(int var6 = 0; var6 < var4; ++var6) {
  398.                if (var8.next() == null) {
  399.                   var8.set(var2);
  400.                   var3 = true;
  401.                }
  402.             }
  403.          } else {
  404.             for(int var9 = 0; var9 < var4; ++var9) {
  405.                if (var1.equals(var8.next())) {
  406.                   var8.set(var2);
  407.                   var3 = true;
  408.                }
  409.             }
  410.          }
  411.       } else if (var1 == null) {
  412.          for(int var5 = 0; var5 < var4; ++var5) {
  413.             if (var0.get(var5) == null) {
  414.                var0.set(var5, var2);
  415.                var3 = true;
  416.             }
  417.          }
  418.       } else {
  419.          for(int var7 = 0; var7 < var4; ++var7) {
  420.             if (var1.equals(var0.get(var7))) {
  421.                var0.set(var7, var2);
  422.                var3 = true;
  423.             }
  424.          }
  425.       }
  426.  
  427.       return var3;
  428.    }
  429.  
  430.    public static int indexOfSubList(List<?> var0, List<?> var1) {
  431.       int var2 = var0.size();
  432.       int var3 = var1.size();
  433.       int var4 = var2 - var3;
  434.       if (var2 < 35 || var0 instanceof RandomAccess && var1 instanceof RandomAccess) {
  435.          label60:
  436.          for(int var10 = 0; var10 <= var4; ++var10) {
  437.             int var11 = 0;
  438.  
  439.             for(int var12 = var10; var11 < var3; ++var12) {
  440.                if (!method_0(var1.get(var11), var0.get(var12))) {
  441.                   continue label60;
  442.                }
  443.  
  444.                ++var11;
  445.             }
  446.  
  447.             return var10;
  448.          }
  449.       } else {
  450.          ListIterator var5 = var0.listIterator();
  451.  
  452.          label48:
  453.          for(int var6 = 0; var6 <= var4; ++var6) {
  454.             ListIterator var7 = var1.listIterator();
  455.  
  456.             for(int var8 = 0; var8 < var3; ++var8) {
  457.                if (!method_0(var7.next(), var5.next())) {
  458.                   for(int var9 = 0; var9 < var8; ++var9) {
  459.                      var5.previous();
  460.                   }
  461.                   continue label48;
  462.                }
  463.             }
  464.  
  465.             return var6;
  466.          }
  467.       }
  468.  
  469.       return -1;
  470.    }
  471.  
  472.    public static int lastIndexOfSubList(List<?> var0, List<?> var1) {
  473.       int var2 = var0.size();
  474.       int var3 = var1.size();
  475.       int var4 = var2 - var3;
  476.       if (var2 >= 35 && !(var0 instanceof RandomAccess)) {
  477.          if (var4 < 0) {
  478.             return -1;
  479.          }
  480.  
  481.          ListIterator var10 = var0.listIterator(var4);
  482.  
  483.          label54:
  484.          for(int var11 = var4; var11 >= 0; --var11) {
  485.             ListIterator var12 = var1.listIterator();
  486.  
  487.             for(int var8 = 0; var8 < var3; ++var8) {
  488.                if (!method_0(var12.next(), var10.next())) {
  489.                   if (var11 != 0) {
  490.                      for(int var9 = 0; var9 <= var8 + 1; ++var9) {
  491.                         var10.previous();
  492.                      }
  493.                   }
  494.                   continue label54;
  495.                }
  496.             }
  497.  
  498.             return var11;
  499.          }
  500.       } else {
  501.          label66:
  502.          for(int var5 = var4; var5 >= 0; --var5) {
  503.             int var6 = 0;
  504.  
  505.             for(int var7 = var5; var6 < var3; ++var7) {
  506.                if (!method_0(var1.get(var6), var0.get(var7))) {
  507.                   continue label66;
  508.                }
  509.  
  510.                ++var6;
  511.             }
  512.  
  513.             return var5;
  514.          }
  515.       }
  516.  
  517.       return -1;
  518.    }
  519.  
  520.    public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> var0) {
  521.       return new UnmodifiableCollection(var0);
  522.    }
  523.  
  524.    public static <T> Set<T> unmodifiableSet(Set<? extends T> var0) {
  525.       return new UnmodifiableSet(var0);
  526.    }
  527.  
  528.    public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> var0) {
  529.       return new UnmodifiableSortedSet(var0);
  530.    }
  531.  
  532.    public static <T> List<T> unmodifiableList(List<? extends T> var0) {
  533.       return (List<T>)(var0 instanceof RandomAccess ? new UnmodifiableRandomAccessList(var0) : new UnmodifiableList(var0));
  534.    }
  535.  
  536.    public static <K, V> Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> var0) {
  537.       return new UnmodifiableMap(var0);
  538.    }
  539.  
  540.    public static <K, V> SortedMap<K, V> unmodifiableSortedMap(SortedMap<K, ? extends V> var0) {
  541.       return new UnmodifiableSortedMap(var0);
  542.    }
  543.  
  544.    public static <T> Collection<T> synchronizedCollection(Collection<T> var0) {
  545.       return new SynchronizedCollection(var0);
  546.    }
  547.  
  548.    static <T> Collection<T> synchronizedCollection(Collection<T> var0, Object var1) {
  549.       return new SynchronizedCollection(var0, var1);
  550.    }
  551.  
  552.    public static <T> Set<T> synchronizedSet(Set<T> var0) {
  553.       return new SynchronizedSet(var0);
  554.    }
  555.  
  556.    static <T> Set<T> synchronizedSet(Set<T> var0, Object var1) {
  557.       return new SynchronizedSet(var0, var1);
  558.    }
  559.  
  560.    public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> var0) {
  561.       return new SynchronizedSortedSet(var0);
  562.    }
  563.  
  564.    public static <T> List<T> synchronizedList(List<T> var0) {
  565.       return (List<T>)(var0 instanceof RandomAccess ? new SynchronizedRandomAccessList(var0) : new SynchronizedList(var0));
  566.    }
  567.  
  568.    static <T> List<T> synchronizedList(List<T> var0, Object var1) {
  569.       return (List<T>)(var0 instanceof RandomAccess ? new SynchronizedRandomAccessList(var0, var1) : new SynchronizedList(var0, var1));
  570.    }
  571.  
  572.    public static <K, V> Map<K, V> synchronizedMap(Map<K, V> var0) {
  573.       return new SynchronizedMap(var0);
  574.    }
  575.  
  576.    public static <K, V> SortedMap<K, V> synchronizedSortedMap(SortedMap<K, V> var0) {
  577.       return new SynchronizedSortedMap(var0);
  578.    }
  579.  
  580.    public static <E> Collection<E> checkedCollection(Collection<E> var0, Class<E> var1) {
  581.       return new CheckedCollection(var0, var1);
  582.    }
  583.  
  584.    public static <E> Set<E> checkedSet(Set<E> var0, Class<E> var1) {
  585.       return new CheckedSet(var0, var1);
  586.    }
  587.  
  588.    public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> var0, Class<E> var1) {
  589.       return new CheckedSortedSet(var0, var1);
  590.    }
  591.  
  592.    public static <E> List<E> checkedList(List<E> var0, Class<E> var1) {
  593.       return (List<E>)(var0 instanceof RandomAccess ? new CheckedRandomAccessList(var0, var1) : new CheckedList(var0, var1));
  594.    }
  595.  
  596.    public static <K, V> Map<K, V> checkedMap(Map<K, V> var0, Class<K> var1, Class<V> var2) {
  597.       return new CheckedMap(var0, var1, var2);
  598.    }
  599.  
  600.    public static <K, V> SortedMap<K, V> checkedSortedMap(SortedMap<K, V> var0, Class<K> var1, Class<V> var2) {
  601.       return new CheckedSortedMap(var0, var1, var2);
  602.    }
  603.  
  604.    public static final <T> Set<T> emptySet() {
  605.       return EMPTY_SET;
  606.    }
  607.  
  608.    public static final <T> List<T> emptyList() {
  609.       return EMPTY_LIST;
  610.    }
  611.  
  612.    public static final <K, V> Map<K, V> emptyMap() {
  613.       return EMPTY_MAP;
  614.    }
  615.  
  616.    public static <T> Set<T> singleton(T var0) {
  617.       return new SingletonSet(var0);
  618.    }
  619.  
  620.    public static <T> List<T> singletonList(T var0) {
  621.       return new SingletonList(var0);
  622.    }
  623.  
  624.    public static <K, V> Map<K, V> singletonMap(K var0, V var1) {
  625.       return new SingletonMap(var0, var1);
  626.    }
  627.  
  628.    public static <T> List<T> nCopies(int var0, T var1) {
  629.       if (var0 < 0) {
  630.          throw new IllegalArgumentException("List length = " + var0);
  631.       } else {
  632.          return new CopiesList(var0, var1);
  633.       }
  634.    }
  635.  
  636.    public static <T> Comparator<T> reverseOrder() {
  637.       return REVERSE_ORDER;
  638.    }
  639.  
  640.    public static <T> Comparator<T> reverseOrder(Comparator<T> var0) {
  641.       return (Comparator<T>)(var0 == null ? reverseOrder() : new ReverseComparator2(var0));
  642.    }
  643.  
  644.    public static <T> Enumeration<T> enumeration(Collection<T> var0) {
  645.       return new 1(var0);
  646.    }
  647.  
  648.    public static <T> ArrayList<T> list(Enumeration<T> var0) {
  649.       ArrayList var1 = new ArrayList();
  650.  
  651.       while(var0.hasMoreElements()) {
  652.          var1.add(var0.nextElement());
  653.       }
  654.  
  655.       return var1;
  656.    }
  657.  
  658.    // $FF: renamed from: eq (java.lang.Object, java.lang.Object) boolean
  659.    private static boolean method_0(Object var0, Object var1) {
  660.       return var0 == null ? var1 == null : var0.equals(var1);
  661.    }
  662.  
  663.    public static int frequency(Collection<?> var0, Object var1) {
  664.       int var2 = 0;
  665.       if (var1 == null) {
  666.          for(Object var4 : var0) {
  667.             if (var4 == null) {
  668.                ++var2;
  669.             }
  670.          }
  671.       } else {
  672.          for(Object var6 : var0) {
  673.             if (var1.equals(var6)) {
  674.                ++var2;
  675.             }
  676.          }
  677.       }
  678.  
  679.       return var2;
  680.    }
  681.  
  682.    public static boolean disjoint(Collection<?> var0, Collection<?> var1) {
  683.       if (var0 instanceof Set && !(var1 instanceof Set) || var0.size() > var1.size()) {
  684.          Collection var2 = var0;
  685.          var0 = var1;
  686.          var1 = var2;
  687.       }
  688.  
  689.       for(Object var3 : var0) {
  690.          if (var1.contains(var3)) {
  691.             return false;
  692.          }
  693.       }
  694.  
  695.       return true;
  696.    }
  697.  
  698.    public static <T> boolean addAll(Collection<? super T> var0, T... var1) {
  699.       boolean var2 = false;
  700.  
  701.       for(Object var6 : var1) {
  702.          var2 |= var0.add(var6);
  703.       }
  704.  
  705.       return var2;
  706.    }
  707.  
  708.    public static <E> Set<E> newSetFromMap(Map<E, Boolean> var0) {
  709.       return new SetFromMap(var0);
  710.    }
  711.  
  712.    public static <T> Queue<T> asLifoQueue(Deque<T> var0) {
  713.       return new AsLIFOQueue(var0);
  714.    }
  715.  
  716.    // $FF: synthetic method
  717.    static boolean access$000(Object var0, Object var1) {
  718.       return method_0(var0, var1);
  719.    }
  720. }
  721.